package com.cjl.leetcodeWeeklyMatch;

import org.junit.jupiter.api.Test;

import java.util.HashMap;

public class Match_382 {

    /**
     * 3019. 按键变更的次数
     * @param s
     * @return
     */
    public int countKeyChanges(String s) {
        // 1.字符串全部转小写
        s = s.toLowerCase();
        // 2.统计转换次数
        int count = 0;
        for (int i = 0; i < s.length() - 1; i++) {
            char a = s.charAt(i);
            char b = s.charAt(i + 1);
            if (a != b) {
                count++;
            }
        }
        return count;
    }

    /**
     * 3020. 子集中元素的最大数量
     *
     * @param nums
     * @return
     */
    public int maximumLength(int[] nums) {
        // 定义hashMap存储每个元素的个数
        HashMap<Long, Integer> map = new HashMap<>();
        for (int num : nums) {
            map.merge((long) num, 1, Integer::sum);
        }
        // 由于1也符合规定子集的要求，如[1, 1, 1]删除其中的键为1的数，并获取1的数量
        Integer n = map.remove(1L);
        // 初始化答案为1的数量，并且保证答案是奇数
        // 如果没有1则结果初始化为0，如果有1则结果舒适化为1的数量，如果1的数量为偶数则需要减一
        // n - (n % 2 ^ 1)：如果n为奇数，则(n % 2 ^ 1)的结果为0，若n为偶数则(n % 2 ^ 1)的结果为1，最后都可以得到我们想要的结果
        int result = n == null ? 0 : n - (n % 2 ^ 1);
        // 开始暴力更新答案
        // 依次遍历每一个key
        for (Long x : map.keySet()) {
            // 当前这一轮的答案
            int res = 0;
            while (true) {
                // 如果不包含这个数则结束循环
                if (!map.containsKey(x)) {
                    // 减去上一轮的奇数情况,循环走到这里表示上一轮循环一定不是两次或两次以上
                    // 比如 [2 4 4 2]，则最后结果只能是[2 4 2]，所以答案要减一
                    res--;
                    break;
                }
                // 如果这个数出现一次则是中间数
                if (map.get(x) == 1) {
                    res++;
                    break;
                }
                // 此时一定是两次或者两次以上
                res += 2;
                // 更新x
                x *= x;
            }
            // 更新最终答案
            result = Math.max(res, result);
        }
        return result;
    }

    public int maximumLength2(int[] nums) {
        // 定义hashMap存储每个元素的个数
        HashMap<Long, Integer> map = new HashMap<>();
        for (int num : nums) {
            map.merge((long) num, 1, Integer::sum);
        }
        // 删除其中的键为1的数，并获取1的数量
        Integer n = map.remove(1L);
        System.out.println(map);
        // 初始化答案为1的数量，并且保证答案是奇数
        int result = n == null ? 0 : n - (n % 2 ^ 1);
        // 开始暴力更新答案
        for (Long x : map.keySet()) {
            int res = 0;
            // 只取x出现次数至少为2的情况
            for (; map.getOrDefault(x, 0) > 1; x *= x) {
                // 每次都加2
                res += 2;
            }
            // 更新最终答案
            // 判断最后一次结果是否包含，如果包含则需要加上这一次情况，如果不包含则多加了一次，需要减1
            result = Math.max(result, res + (map.containsKey(x) ? 1 : -1));
        }
        return result;
    }

    /**
     * 3021. Alice 和 Bob 玩鲜花游戏
     * @param n
     * @param m
     * @return
     */
    public long flowerGame(int n, int m) {
        // return (long)n * m / 2;
        return (long) ((n / 2) * Math.ceil((double) (m / 2)) + (m / 2) * Math.ceil((double) (n / 2)));
    }

    @Test
    void test() {
        maximumLength2(new int[]{5, 4, 1, 2, 2});
    }
}
